package progetto.misure;

import grafi.Grafo;
import grafi.Arco;

import java.util.Iterator;

public class MisureUtil
{

        	
	  public static double[][] matriceProdotto(double A[][], double B[][])
	  {
			if (A == null | B == null)
				  return null;

			int rA = A.length;
			int rB = B.length;

			int cA = A[0].length;
			int cB = B[0].length;

			if (rB != cA)
			{
				  System.out.println("Matrici non compatibili!");
				  return null;
			}

			double P[][] = new double[rA][cB];

			double somma;

			for (int i = 0; i < rA; i++)
			{
				  for (int j = 0; j < cB; j++)
				  {
						somma = 0;
						for (int k = 0; k < rB; k++)
							  somma += A[i][k] * B[k][j];
						P[i][j] = somma;
				  }
			}
			return P;
	  }

	  /*
	   * Il metodo prodottoMatriceVettore è un caso particolare di
	   * prodottoMatrice, decidere se tenerli tutti e due o solo uno. In
	   * quest'ultimo caso bisogna ricordarsi di definire p come int[][1] e non
	   * come int[]
	   */

	  public static double[] prodottoMatriceVettore(double M[][], double p[])
	  {
			if (M == null | p == null)
				  return null;

			int rM = M.length;
			int cM = M[0].length;

			if (cM != p.length)
				  throw new IllegalArgumentException();

			double p1[] = new double[rM];

			for (int i = 0; i < p1.length; i++)
				  p1[i] = 0;

			for (int i = 0; i < rM; i++)
			{
				  for (int j = 0; j < cM; j++)
				  {
						p1[i] += M[i][j] * p[j];
				  }
			}
			return p1;
	  }

	  public static double[] prodottoScalareVettore(double p[], double a)
	  {
			for (int i = 0; i < p.length; i++)
				  p[i] *= a;
			return p;
	  }
	  
	  public static double[][] matriceTrasposta(double M[][])
	  {
			int rM = M.length;
			int cM = M[0].length;
			double Mt[][] = new double[cM][rM];
			for (int i = 0; i < rM; i++)
				  for (int j = 0; j < cM; j++)
						Mt[j][i] = M[i][j];
			return Mt;
	  }

	  public static double[] sommaVettori(double p[], double q[])
	  {
			if (p.length != q.length)
				  throw new IllegalArgumentException();

			double w[] = new double[p.length];
			for (int i = 0; i < p.length; i++)
				  w[i] = p[i] + q[i];
			return w;
	  }

	  public static void printMatrice(double x[][])
	  {

			for (int i = 0; i < x.length; i++)
			{
				  System.out.print(i + "|");
				  for (int j = 0; j < x[0].length; j++)
				  {
						if (x[i][j] == Double.POSITIVE_INFINITY)
							  System.out.print(x[i][j] + " ");
						else
							  System.out.print(x[i][j] + "      ");
				  }
				  System.out.println("");
			}
			System.out.println("");
	  }

	  public static void printArray(double v[])
	  {
			System.out.print("[");

			for (int i = 0; i < v.length - 1; i++)
				  System.out.print(v[i] + " ");

			System.out.print(v[v.length - 1] + "];");
	  }





//	  public static void main(String[] args)
//	  {
//			// TODO Auto-generated method stub
//
//			double M[][] = { { 0, 1 / 2.0, 1, 0 }, { 1 / 3.0, 0, 0, 1 / 2.0 },
//						{ 1 / 3.0, 0, 0, 1 / 2.0 }, { 1 / 3.0, 1 / 2.0, 0, 0 } };
//
//			double L[][] = { { 0, 1, 1, 1, 0 }, { 1, 0, 0, 1, 0 },
//						{ 0, 0, 0, 0, 1 }, { 0, 1, 1, 0, 0 }, { 0, 0, 0, 0, 0 } };
//
//			double m1[][] = { { 0, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
//						{ 0, 0, 0, 0 } };
//
//			double p[] = calcolaPageRank(m1, 50);
//			System.out.print("p = ");
//
//			printArray(p);
//
//			double a[] = calcolaHits(L, 50);
//			/*
//			 * System.out.println("A = "); printMatrice(A);
//			 * System.out.println();
//			 */
//
//			/*
//			 * double p[] = {1.0, 0.0, 2.1, 3.1, 1.1}; double p1[] =
//			 * prodottoScalareVettore(p,5.0); // p1 =
//			 * prodottoMatriceVettore(A,p);
//			 */
//
//			System.out.print("\n\n a = ");
//
//			printArray(a);
//			// System.out.println();
//
//			/*
//			 * System.out.println("At = "); printMatrice(matriceTrasposta(A));
//			 * System.out.println();
//			 */
//	  }

}
